// pages/myShare/myShare.js
const api = require('../../../utils/api');

// 格式化时间函数
function formatTime(dateStr) {
  if (!dateStr) return '';
  
  const date = new Date(dateStr);
  if (isNaN(date.getTime())) return '';
  
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  
  return `${year}-${month}-${day} ${hours}:${minutes}`;
}

Page({
  data: {
    userInfo: {},    // 当前用户信息
    myShares: []     // 我的历史分享列表
  },

  onLoad() {
    // 加载时：1. 获取当前用户信息 2. 获取我的历史分享
    this.getUserInfo();
    this.getMyShares();
  },

  // 获取当前用户信息
  getUserInfo: function() {
    return new Promise((resolve) => {
      // 优先从API获取实际登录用户的数据
      console.log('优先从API获取最新用户信息');
      
      // 首先检查是否有登录令牌
      const token = wx.getStorageSync('token');
      
      if (!token) {
        console.log('未检测到登录状态，使用默认用户信息');
        const defaultUserInfo = {
          avatar: '/static/pic/icon-test.png',
          avatarUrl: '/static/pic/icon-test.png',
          name: '用户',
          nickname: '用户'
        };
        this.setData({ userInfo: defaultUserInfo });
        resolve(defaultUserInfo);
        return;
      }
      
      // 尝试从userId获取用户ID
      const userId = wx.getStorageSync('userId');
      
      // 调用API获取用户信息，优先使用实际用户ID，没有则使用'current'
      api.my.getUserInfo(userId || 'current').then(res => {
        if (res && typeof res === 'object') {
          // 标准化用户信息格式
          const userInfo = {
            ...res,
            id: res.id || res.userId || userId,
            userId: res.id || res.userId || userId,
            name: res.name || res.nickname || res.username || '用户',
            avatar: res.avatar || res.avatarUrl || '/static/pic/icon-test.png',
            nickname: res.nickname || res.name || res.username || '用户',
            avatarUrl: res.avatarUrl || res.avatar || '/static/pic/icon-test.png'
          };
          
          console.log('成功从API获取用户信息:', userInfo);
          this.setData({ userInfo });
          
          // 保存到本地以便其他页面使用
          wx.setStorageSync('userInfo', userInfo);
          
          resolve(userInfo);
        } else {
          console.warn('API返回的用户信息不完整或为空:', res);
          
          // 尝试从本地存储获取，即使之前有清理过
          const cachedUserInfo = wx.getStorageSync('userInfo');
          if (cachedUserInfo && (cachedUserInfo.id || cachedUserInfo.userId)) {
            if (cachedUserInfo.id !== 1 && cachedUserInfo.userId !== 1) {
              console.log('使用缓存的用户信息作为备选');
              this.setData({ userInfo: cachedUserInfo });
              resolve(cachedUserInfo);
              return;
            }
          }
          
          // 失败时使用最小默认用户信息
          const defaultUserInfo = {
            id: userId,
            userId: userId,
            avatar: '/static/pic/icon-test.png',
            avatarUrl: '/static/pic/icon-test.png',
            name: '用户',
            nickname: '用户'
          };
          this.setData({ userInfo: defaultUserInfo });
          resolve(defaultUserInfo);
        }
      }).catch(err => {
        console.error('获取用户信息API调用失败:', err);
        
        // 错误时尝试使用本地存储的用户信息
        const cachedUserInfo = wx.getStorageSync('userInfo');
        if (cachedUserInfo && (cachedUserInfo.id || cachedUserInfo.userId)) {
          if (cachedUserInfo.id !== 1 && cachedUserInfo.userId !== 1) {
            console.log('API调用失败，使用缓存的用户信息');
            this.setData({ userInfo: cachedUserInfo });
            resolve(cachedUserInfo);
            return;
          }
        }
        
        // 使用最小默认用户信息
        const defaultUserInfo = {
          id: userId,
          userId: userId,
          avatar: '/static/pic/icon-test.png',
          avatarUrl: '/static/pic/icon-test.png',
          name: '用户',
          nickname: '用户'
        };
        this.setData({ userInfo: defaultUserInfo });
        resolve(defaultUserInfo);
      });
    });
  },
  
  // 获取我的分享列表
  getMyShares: async function() {
    try {
      // 检查并清除错误的缓存用户信息（如果userId为1）
      const currentUserInfo = wx.getStorageSync('userInfo');
      if (currentUserInfo && currentUserInfo.userId === 1) {
        console.log('发现错误的用户ID 1，清除缓存并使用默认值');
        wx.removeStorageSync('userInfo');
      }
      
      // 首先加载本地备份数据，确保用户能立即看到自己发布的内容
      const backupShares = wx.getStorageSync('backupShares') || [];
      console.log('本地备份数据数量:', backupShares.length);
      
      // 检查登录状态
      const token = wx.getStorageSync('token');
      const userInfo = wx.getStorageSync('userInfo');
      
      // 优先使用id字段，然后是userId字段，并避免使用固定默认值
    let userId = 2; // 使用正确的默认值
    
    // 检查并使用用户信息中的ID字段（id或userId）
    if (this.data.userInfo) {
      if (this.data.userInfo.id && this.data.userInfo.id !== 1) {
        userId = this.data.userInfo.id;
      } else if (this.data.userInfo.userId && this.data.userInfo.userId !== 1) {
        userId = this.data.userInfo.userId;
      }
    } else if (userInfo) {
      if (userInfo.id && userInfo.id !== 1) {
        userId = userInfo.id;
      } else if (userInfo.userId && userInfo.userId !== 1) {
        userId = userInfo.userId;
      }
    }
      
      console.log('开始获取用户ID为', userId, '的分享列表');
      
      // 优先显示本地备份数据
      if (backupShares.length > 0) {
        console.log('优先使用本地备份数据显示');
        const formattedData = this.formatShareData(backupShares);
        this.setData({
          myShares: formattedData
        });
        wx.showToast({
          title: '已显示本地分享内容',
          icon: 'none',
          duration: 1500
        });
      }
      
      // 如果没有登录，不再尝试API调用
      if (!token) {
        console.log('未检测到登录状态，只显示本地备份数据');
        return;
      }
      
      // 已登录状态：尝试从API获取最新数据
      try {
        // 调用API获取我的分享列表
        const res = await api.community.getUserShares(userId);
        console.log('API返回的原始数据:', res);
        
        // 处理API返回的数据，确保数据格式与页面显示匹配
        let sharesData = [];
        
        // 检查返回数据结构，增加更多的兼容性处理
        if (Array.isArray(res)) {
          sharesData = res;
          console.log('直接获取到数组数据，长度:', sharesData.length);
        } else if (res && Array.isArray(res.data)) {
          sharesData = res.data;
          console.log('从res.data获取到数组，长度:', sharesData.length);
        } else if (res && Array.isArray(res.items)) {
          sharesData = res.items;
          console.log('从res.items获取到数组，长度:', sharesData.length);
        } else if (res && Array.isArray(res.shares)) {
          sharesData = res.shares;
          console.log('从res.shares获取到数组，长度:', sharesData.length);
        } else if (res && typeof res === 'object') {
          // 可能是单个对象而不是数组
          console.log('检测到非数组对象，尝试转换为数组');
          if (res.id || res.title || res.createTime) {
            sharesData = [res];
          } else {
            console.warn('返回的数据格式不符合预期，无法识别');
          }
        } else {
          console.warn('返回的数据格式不符合预期:', typeof res);
        }
        
        // 合并API数据和本地备份数据，避免重复
        const mergedShares = this.mergeShareData(sharesData, backupShares);
        
        // 为每个分享项添加必要的字段，确保兼容性
        const sharesWithLikeStatus = this.formatShareData(mergedShares);
        
        // 按创建时间倒序排序，确保最新的在前面
        sharesWithLikeStatus.sort((a, b) => {
          const timeA = a.createTime ? new Date(a.createTime).getTime() : 0;
          const timeB = b.createTime ? new Date(b.createTime).getTime() : 0;
          return timeB - timeA;
        });
        
        this.setData({
          myShares: sharesWithLikeStatus
        });
        
        console.log('处理后的分享列表数据:', sharesWithLikeStatus);
      } catch (apiError) {
        console.error('API调用失败，继续使用本地备份:', apiError);
        
        // 500错误时，确保已显示本地备份数据
        if (apiError && apiError.statusCode === 500) {
          console.error('服务器错误，已显示本地数据作为替代');
          if (backupShares.length === 0) {
            wx.showToast({
              title: '服务器暂时不可用，暂无分享内容',
              icon: 'none'
            });
          }
        }
      }
    } catch (outerError) {
      console.error('getMyShares方法执行出错:', outerError);
      // 确保显示本地数据或空数组
      const backupShares = wx.getStorageSync('backupShares') || [];
      if (backupShares.length > 0) {
        const formattedData = this.formatShareData(backupShares);
        this.setData({
          myShares: formattedData
        });
      } else {
        this.setData({
          myShares: []
        });
      }
    }
  },
  
  // 合并API数据和本地备份数据，避免重复
  mergeShareData: function(apiData, backupData) {
    if (!apiData || apiData.length === 0) return backupData;
    if (!backupData || backupData.length === 0) return apiData;
    
    // 创建一个Map来存储已存在的分享，避免重复
    const shareMap = new Map();
    
    // 先添加API数据
    apiData.forEach(share => {
      if (share.id) {
        shareMap.set(share.id.toString(), share);
      }
    });
    
    // 再添加本地备份数据（如果不存在于API数据中）
    backupData.forEach(share => {
      const key = share.id ? share.id.toString() : `backup_${share.createTime}`;
      if (!shareMap.has(key)) {
        shareMap.set(key, share);
      }
    });
    
    // 将Map转换回数组
    return Array.from(shareMap.values());
  },
  
  // 增强的格式转换方法
  formatShareData(rawData) {
    try {
      if (!Array.isArray(rawData)) return [];
      
      return rawData.map(item => {
        try {
          // 创建基本对象，包含所有必需字段的默认值
          const formatted = {
            ...item,
            // 确保存在必要字段
            id: item.id || item.postId || Date.now(), // 增加更多可能的ID字段来源
            isLiked: item.isLiked || false,
            favoriteCount: item.favoriteCount || item.likeCount || item.favorite_count || 0,
            commentCount: item.commentCount || item.comment_count || 0,
            // 添加兼容字段
            desc: item.description || item.desc || item.content || '',
            title: item.title || '未命名分享',
            imageUrls: this.formatImageUrls(item.imageUrls || item.images || item.imgUrls || []),
            // 确保时间字段存在
            createTime: this.getValidTime(item.createTime || item.create_time || new Date().toISOString())
          };
          
          return formatted;
        } catch (itemError) {
          console.error('格式化单个分享数据时出错:', itemError, item);
          // 返回一个最小化的有效对象
          return {
            id: Date.now(),
            title: '未命名分享',
            desc: '',
            imageUrls: [],
            createTime: new Date().toISOString(),
            favoriteCount: 0,
            commentCount: 0,
            isLiked: false
          };
        }
      });
    } catch (e) {
      console.error('格式化分享数据数组时出错:', e);
      return [];
    }
  },
  
  // 处理图片URL数组
  formatImageUrls(imageUrls) {
    try {
      // 确保是数组
      if (!Array.isArray(imageUrls)) {
        return [];
      }
      
      // 过滤并清理图片URL
      return imageUrls
        .filter(url => url && typeof url === 'string')
        .map(url => {
          // 清理URL中的多余字符
          return url.replace(/^["']|["']$/g, '').trim();
        })
        .slice(0, 9); // 最多保留9张图
    } catch (e) {
      console.error('格式化图片URL时出错:', e);
      return [];
    }
  },
  
  // 获取有效的时间字符串
  getValidTime(time) {
    try {
      if (!time) {
        return new Date().toISOString();
      }
      
      // 检查是否已经是有效的Date对象
      const date = new Date(time);
      if (isNaN(date.getTime())) {
        // 无效时间，返回当前时间
        return new Date().toISOString();
      }
      
      return date.toISOString();
    } catch (e) {
      console.error('处理时间数据时出错:', e);
      return new Date().toISOString();
    }
  },
  
  // 修改分享
  editShare(e) {
    const id = e.currentTarget.dataset.id;
    const desc = e.currentTarget.dataset.desc;
    
    wx.showModal({
      title: '修改分享',
      content: '确定要修改这条分享吗？',
      success: (res) => {
        if (res.confirm) {
          // 构建修改数据
      const updateData = {
        id: id,
        description: desc
      };
           
          // 跳转到编辑页面，传递分享数据，使用content参数确保正文内容正确显示
          wx.navigateTo({
            url: `/pages/community/shareEdit/shareEdit?id=${id}&title=${encodeURIComponent(e.currentTarget.dataset.title)}&content=${encodeURIComponent(desc)}&imageUrls=${encodeURIComponent(JSON.stringify(e.currentTarget.dataset.imageurls || []))}`
          });
          // 注：实际修改操作在shareEdit页面完成
        }
      }
    });
  },
  
  // 删除分享
  deleteShare(e) {
    // 参数有效性检查
    if (!e || !e.currentTarget || !e.currentTarget.dataset || !e.currentTarget.dataset.id) {
      console.error('删除失败：ID无效');
      wx.showToast({
        title: '删除失败：参数错误',
        icon: 'none'
      });
      return;
    }
    
    const id = e.currentTarget.dataset.id;
    
    wx.showModal({
      title: '删除分享',
      content: '确定要删除这条分享吗？',
      success: (res) => {
        if (res.confirm) {
          try {
            // 1. 立即从当前显示的列表中移除该项
            const myShares = this.data.myShares || [];
            const updatedShares = Array.isArray(myShares) ? 
              myShares.filter(item => item && item.id !== id) : [];
            
            // 更新UI，使帖子立即消失
            this.setData({
              myShares: updatedShares
            });
            
            // 2. 从本地备份中删除对应帖子
            try {
              const backupShares = wx.getStorageSync('backupShares') || [];
              const updatedBackupShares = Array.isArray(backupShares) ? 
                backupShares.filter(item => {
                  // 考虑不同的ID存储方式
                  try {
                    const itemId = item && item.id ? 
                      item.id.toString() : 
                      (item && item.createTime ? `backup_${item.createTime}` : null);
                    const targetId = id.toString();
                    return itemId !== targetId;
                  } catch (e) {
                    console.error('处理备份项ID失败:', e);
                    return true; // 出错时保留该项
                  }
                }) : [];
              
              wx.setStorageSync('backupShares', updatedBackupShares);
              console.log('已从本地备份中删除帖子，剩余备份数量:', updatedBackupShares.length);
            } catch (e) {
              console.error('处理本地备份失败:', e);
            }
            
            // 3. 调用API删除服务器上的分享
            api.community.deleteShare(id).then(() => {
              wx.showToast({
                title: '删除成功',
                icon: 'success'
              });
              // 可以选择不刷新，因为UI已经更新
            }).catch(err => {
              console.error('删除分享失败:', err);
              wx.showToast({
                title: '服务器删除失败，但已从本地移除',
                icon: 'none'
              });
              // 注意：这里不恢复已删除的UI，保持用户体验一致性
            });
          } catch (error) {
            console.error('删除操作发生错误:', error);
            wx.showToast({
              title: '删除过程中发生错误',
              icon: 'none'
            });
            // 尝试重新加载数据以恢复正确状态
            this.getMyShares();
          }
        }
      }
    });
  },
  
  // 切换点赞状态
  toggleLike(e) {
    const postId = e.currentTarget.dataset.id;
    const myShares = this.data.myShares;
    
    // 查找并切换点赞状态
    const updatedShares = myShares.map(item => {
      if (item.id === postId) {
        return {
          ...item,
          isLiked: !item.isLiked
        };
      }
      return item;
    });
    
    // 更新数据
    this.setData({
      myShares: updatedShares
    });
    
    // 可以在这里调用API更新点赞状态
    console.log(`帖子${postId}点赞状态已切换为${updatedShares.find(item => item.id === postId).isLiked}`);
  },
  
  // 发布帖子
  publishPost() {
    // 跳转到分享编辑页面
    wx.navigateTo({
      url: '/pages/community/shareEdit/shareEdit'
    });
  },
  
  // 格式化时间显示
  formatTime(dateStr) {
    return formatTime(dateStr);
  },
  
  // 页面显示时刷新分享列表和用户信息（从分享编辑页面返回时会触发）
  onShow() {
    // 重新获取最新用户信息，确保与登录状态同步
    this.getUserInfo().then(() => {
      // 强制刷新分享列表
      setTimeout(() => {
        this.getMyShares();
      }, 300); // 添加小延迟确保数据已更新
    });
  },
  
  // 下拉刷新，更新用户信息和分享列表
  onPullDownRefresh() {
    console.log('触发下拉刷新，更新用户信息和分享列表');
    // 先更新用户信息
    this.getUserInfo().then(() => {
      // 然后刷新分享列表
      this.getMyShares().then(() => {
        // 结束下拉刷新
        wx.stopPullDownRefresh();
        console.log('下拉刷新完成');
      }).catch(() => {
        // 即使分享列表刷新失败也要结束下拉刷新
        wx.stopPullDownRefresh();
      });
    }).catch(() => {
      // 即使用户信息更新失败也要结束下拉刷新
      wx.stopPullDownRefresh();
    });
  }
});
